package 行为型模式


/**
 * 给定一个语言，定义它的文法的一种表示，
 * 并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
 * 解释器模式通过抽象语法树实现对用户输入的解释执行。
 * 解释器模式的实现通常非常复杂，且一般只能解决一类特定问题。
 */

// 上下文环境
class Context(private val expression: String) {
    fun evaluate(): Expression {
        // 将表达式解析成抽象语法树
        val tokens = expression.split(" ")
        val stack = mutableListOf<Expression>()

        for (token in tokens) {
            if (isOperator(token)) {
                val right = stack.removeAt(stack.lastIndex)
                val left = stack.removeAt(stack.lastIndex)

                val operator = when (token) {
                    "+" -> AddExpression(left, right)
                    else -> throw IllegalArgumentException("Unsupported operator")
                }
                stack.add(operator)
            } else {
                val operand = NumberExpression(token.toInt())
                stack.add(operand)
            }
        }
        return stack.single()
    }

    private fun isOperator(token: String): Boolean {
        return token == "+"
    }
}

// 抽象表达式
interface Expression {
    fun interpret(): Int
}

// 终结符表达式: 数字表达式
class NumberExpression(private val number: Int) : Expression {
    override fun interpret(): Int {
        return number
    }
}

class AddExpression(private val left: Expression, private val right: Expression) : Expression {
    override fun interpret(): Int {
        return left.interpret() + right.interpret()
    }
}

fun main(args: Array<String>) {
    val expression = "1 2 + 3 4 + +"

    val context = Context(expression)
    val e = context.evaluate()

    val result = e.interpret()
    println("结果：$result")
}

